Details for this torrent 

Let's Get Rusty | Rust Developer Bootcamp [FCO]
Type:
Other > Other
Files:
109
Size:
2.9 GiB (3117368497 Bytes)
Uploaded:
2024-01-28 20:16:42 GMT
By:
Prom3th3uS Trusted
Seeders:
11
Leechers:
0
Comments
0  

Info Hash:
7CC772D05BCB5465EDA218961E72F2A87CC34C68




(Problems with magnets links are fixed by upgrading your torrent client!)
Lynda and other Courses >>> https://freecoursesonline.me/
Forum for discussion >>> https://onehack.us/

https://get.freecoursesonline.me/wp-content/uploads/2024/01/lets-get-rusty.png

Let's Get Rusty - Rust Developer Bootcamp [FCO]

About

Lets Get Rusty - Bootcamp for Rust developers

Who is this bootcamp for? Experienced developers who want to switch to Rust. Learn the language of the future. Your time is valuable ($148,688/year, literally). Learn Rust FAST with a bootcamp instead of digging through poor quality resources. Students/Graduates looking for work. Learning Rust is a great addition to a resume. Stand out from other candidates. Become a competent programmer. Gain access to a community that can help you find your first job. And you! Rust enthusiast. Rust is an innovative language that will expand your thinking! Cutting-edge technologies are created in Rust.

You will learn how to set up your development environment, configure your development environment (IDE), and install the necessary plugins. Then you'll create your first Rust project!

You will learn:

• How to Set Up Your Development Environment
• Setting up your IDE and plugins
• Creating Rust Packages Using Cargo
• Variables and Data Types in Rust
• Constant and static variables
• Functions and Flow Control

Understanding memory management is critical when learning Rust! In this section, you'll learn about memory management from the very beginning!

You will learn:

• Computer Science Masterclass Based on Rust
• How does the ownership mechanism work?
• How does the borrowing mechanism work?
• What are slices
• String types (str, &str and String)

Rust doesn't use classes or objects! Instead, Rust uses Structs and Enums to create custom data types. In this section, you'll learn how to create your own types!

You will learn:

• How to create structures and enumerations
• How to use implementation blocks
• Pattern matching
• Option and Result enumerations
• Vectors

How to Structure Your Rust Projects

In this section, I will explain how modules work in a clear way. I'll also talk about structuring larger projects and publishing your work on Crates.io.

You will learn:

• Project structure overview
• Module system
• External dependencies
• Conditional compilation
• How to structure large projects
• Publishing your projects in Rust

How to Test and Document Your Code

Tests are a critical part of writing reliable code. In this section, you'll learn how to write and structure unit and integration tests in Rust. We will also look at documentation issues.

You will learn:

• How to Write Unit Tests
• How to write integration tests
• How to structure your tests
• Comments on the documentation

Polymorphism Using Generics and Traits

Rust doesn't support classical inheritance! Instead, polymorphism is achieved through generics and traits. In this section, you will learn how both of these mechanisms work.

You will learn:

• How to identify generics
• Trait system
• Trait Boundaries and Trait Objects
• Supertraits
• Static dispatching vs dynamic dispatching
• How to display traits
• Traits in the standard library

Advanced Memory Management

Memory management doesn't end with owning and borrowing mechanisms! In this section you will learn about lifetimes! We'll also look at various smart pointers in Rust.

You will learn:

• Concrete Lifetimes
• Generic Lifetimes Annotations
• Lifetimes in functions and structures
• Smart pointers and why they are useful
• Implicit Deref Coercion

Understanding Error Handling in Rust

Understanding error handling is critical when designing your Rust applications. In this section, we'll look at how error handling works in Rust.

You will learn:

• How to generate uncorrectable errors
• How to return correctable errors
• How to propagate bugs
• Result and Option enumerations
• How to Handle Many Types of Errors
• How to use anyhow and thiserror

Functional Features in Rust

One of the most powerful features of Rust is its functionality. In this section, we'll look at closures, function pointers, iterators, and more!

You will learn:

• Closures and function pointers
• Iterator Pattern in Rust
• Implementing the Iterator Pattern
• How to iterate through collections
• Combinators and how to use them

Concurrency and async/.await

This is probably the MOST IMPORTANT section. Understanding concurrency is critical, especially when using Rust for web projects.

You will learn:

• Basic Concurrency Concepts
• Creating Threads
• Messaging using channels
• Sharing State with Mutex
• async/.await model
• How Futures work (future results)
• What is asynchronous execution
• What is Tokio and how is it used?
• What are Tokio tasks
• Executing CPU-Blocking Code
• Data Streams

Rust's Powerful Macro System

Macros are an extremely powerful way to extend the syntax of a language. In this section, you'll learn about Rust's macro system from the very beginning!

• Compilation process
• What are macros
• How to Create Declarative Macros
• How to Create Procedural Macros
• Function-like procedural macros
• Attribute-like procedural macros
• Custom procedural macros based on derived types (Custom Derive)

Insecure Rust and FFI (Foreign Function Interface)

One of Rust's significant advantages is its ability to interact with other languages ​​through an external function interface. In this section you will learn about insecure Rust and FFI!

You will learn:

• Insecure Rust and when to use it
• How to dereference raw pointers
• What are unsafe functions
• What are unsafe traits?
• How to change static variables
• How to Write Assembly Inline Commands in Rust
• How to Call C Code from Rust
• How to Call Rust Code from C

Instructor:

Hi, I'm Bogdan, the founder of Let's Get Rusty, and I will personally be running this bootcamp. My journey learning Rust was *far* from smooth or easy. I did not have a traditional 4 year computer science degree. And although I worked for a large technology company (Salesforce), my focus has always been on front-end development. So I was completely new to low level programming. Also, when I started, there weren't many beginner-friendly resources for learning Rust. My journey of learning Rust was long and painful... But I never gave up! I never made excuses and always kept moving forward. My experience learning Rust inspired me to help others...

Media Information:

MP4 | Video: h264, 1920x1080p | Audio: AAC, 44.100 KHz, 2 Ch
Genre: eLearning | Language: English | Last updated: 01/05/2024 | Duration: 105 lectures ( 9h 50m 20s ) | Author: Bogdan

Course Source: https://checkout.letsgetrusty.com/bootcamp

0. Websites you may like/1. OneHack.us Premium Cracked Accounts-Tutorials-Guides-Articles Community Based Forum.url377 B
0. Websites you may like/2. FTUApps.com Download Cracked Developers Applications For Free.url239 B
001. Don't skip this video!.mp4146.57 MiB
002. How to use this Bootcamp effectively.mp4111.17 MiB
003. Hello World.mp48.54 MiB
004. Variables.mp410.13 MiB
005. Data Types.mp413.94 MiB
006. Constants & Statics.mp46.56 MiB
007. Functions.mp49.89 MiB
008. Control Flow.mp411.54 MiB
009. Comments.mp42.2 MiB
010. Stack, Heap, and Static Memory.mp426.23 MiB
011. Memory Management Strategies.mp413.61 MiB
012. C++ RAII vs Rust OBRM - Part 1.mp449.66 MiB
013. C++ RAII vs Rust OBRM - Part 2.mp426.06 MiB
014. Ownership.mp425.78 MiB
015. Ownership Continued.mp434.17 MiB
016. Borrowing.mp443.11 MiB
017. Slices.mp440.49 MiB
018. BONUS Masterclass Strings in Rust. PART 1.mp467.82 MiB
019. BONUS Masterclass Strings in Rust. PART 2.mp470.87 MiB
020. Structs.mp412.57 MiB
021. Implementation Blocks.mp431.89 MiB
022. Tuple Structs.mp45.95 MiB
023. Enums.mp422.67 MiB
024. Matching.mp433.32 MiB
025. Option.mp423.58 MiB
026. Result.mp420.53 MiB
027. Vectors.mp427.25 MiB
028. Project Structure Overview.mp422.04 MiB
029. Modules.mp467.25 MiB
030. Modules Continued.mp440.44 MiB
031. External Dependencies.mp417.76 MiB
032. Publishing Your Package.mp428.03 MiB
033. Cargo Features.mp428.46 MiB
034. Cargo Workspaces.mp421.55 MiB
035. Unit Tests.mp457.32 MiB
036. Integration Tests.mp418.13 MiB
037. Documentation.mp410.82 MiB
038. BONUS Benchmark Testing.mp421.27 MiB
039. Generics.mp454.19 MiB
040. Traits.mp425.11 MiB
041. Trait Bounds.mp424.88 MiB
042. Supertraits.mp47.7 MiB
043. Trait Objects.mp432.06 MiB
044. Deriving Traits.mp411.42 MiB
045. The Orphan Rule.mp413.88 MiB
046. Concrete Lifetimes.mp420.36 MiB
047. Generic Lifetimes.mp440.38 MiB
048. Structs & Lifetime Elision.mp440.31 MiB
049. Box Smart Pointer.mp425.5 MiB
050. Rc Smart Pointer.mp415.02 MiB
051. RefCell Smart Pointer.mp424.51 MiB
052. Deref Coercion.mp426.62 MiB
053. Unrecoverable Errors.mp49.15 MiB
054. Recoverable Errors.mp416.37 MiB
055. Propagating Errors.mp420.42 MiB
056. Result and Option.mp421.01 MiB
057. Multiple Error Types.mp427.31 MiB
058. Overview of Error Handling.mp414.87 MiB
059. Basic Error Handling.mp461.49 MiB
060. Custom Errors 1.mp436.53 MiB
061. Custom Errors 2.mp452.73 MiB
062. Custom Errors 3.mp443.6 MiB
063. thiserror & anyhow.mp432.1 MiB
064. BONUS error-stack.mp4141.83 MiB
065. Closures.mp468.48 MiB
066. Closures Continued.mp432 MiB
067. Function Pointers.mp418.93 MiB
068. Iterator Pattern.mp428.17 MiB
069. Iterator Pattern Continued.mp426.11 MiB
070. Iterating Over Collections.mp49.61 MiB
071. Combinators.mp452.03 MiB
072. Intro to Concurrency.mp429.68 MiB
073. Creating Threads.mp415.81 MiB
074. Moving Values Into Threads.mp43.81 MiB
075. Message Passing Between Threads.mp423.89 MiB
076. Sharing State Between Threads.mp411.94 MiB
077. Sharing State Between Threads Continued.mp418.01 MiB
078. Send & Sync Traits.mp410.37 MiB
079. async.await Basics.mp435.83 MiB
080. Tokio Tasks.mp423.67 MiB
081. CPU Intensive Code.mp411.04 MiB
082. Streams.mp48.44 MiB
083. Intro to Macros.mp417.97 MiB
084. Declarative Macros.mp411.99 MiB
085. Declarative Macros Continued.mp428.92 MiB
086. Procedural Macros.mp46.47 MiB
087. Procedural Macros - Function Like.mp420.96 MiB
088. Procedural Macros - Custom Derive.mp434.15 MiB
089. Procedural Macros - Attribute Like.mp439.21 MiB
090. Procedural Macros - Attribute Continued.mp440.35 MiB
091. Unsafe Basics.mp45.02 MiB
092. Dereferencing a Raw Pointer.mp410.52 MiB
093. Calling an Unsafe Function.mp46.56 MiB
094. Implementing an Unsafe Trait.mp48.88 MiB
095. Mutable Static Variables.mp45.3 MiB
096. Inline Assembly.mp44.43 MiB
097. FFI C from Rust.mp413.63 MiB
098. FFI Rust from C.mp47.52 MiB
099. BONUS FFI Rust from Python.mp442.36 MiB
100. What are microservices.mp414.94 MiB
101. Why Rust is great for microservices.mp45 MiB
102. Communication with gRPC.mp416.29 MiB
103. Containerization with Docker.mp4120.1 MiB
104. CICD with GitHub Actions.mp46.28 MiB
105. Cloud Providers.mp49.79 MiB
FreeCoursesOnline.me Download Udacity, Masterclass, Lynda, PHLearn, etc Free.url29 B
Support Us.txt185 B